package IO.序列化.io1;

public class fastjson2的使用 {

}
1，什么是fastjson？
fastjson是阿里巴巴开源的JSON解析库，它可以解析JSON格式的字符串，支持将Java Bean序列化为JSON字符串，也可以从JSON字符串反序列化到JavaBean。
fastjson具有速度快、使用广泛、测试完备、简单易用等特点，虽然之前曾被曝出存在一些漏洞风险，从源码分析来看主要是从2019年7月份发布的v1.2.59一直到2020年6月份发布的 v1.2.71 ，每个版本的升级中都有关于AutoType的升级，此次fastjson2.0对此进行了全面优化，下面就一起来快速的上手体验一下吧~

2，快速使用
2.1 maven依赖
<dependency>
 <groupId>com.alibaba.fastjson2</groupId>
 <artifactId>fastjson2</artifactId>
 <version>2.0.1</version>
</dependency>
在fastjson2.0中，package和1.x是有所不同的，在引入依赖时要特别注意

2.2 常用API基本使用
package IO.序列化;

class JSON {
    // 将字符串解析成JSONObject
    static JSONObject parseObject(String str);
    
    // 将字符串解析成JSONArray
    static JSONArray parseArray(String str);
    
    // 将字符串解析成Java对象
    static T parseObject(byte[] utf8Bytes, Class<T> objectClass);

    // 将Java对象输出成字符串
    static String toJSONString(Object object);
    
    // 将Java对象输出成UT8编码的byte[]
    static byte[] toJSONBytes(Object object);
}

class JSONB {
    // 将jsonb格式的byte[]解析成Java对象
    static T parseObject(byte[] jsonbBytes, Class<T> objectClass);
    
    // 将Java对象输出成jsonb格式的byte[]
    static byte[] toBytes(Object object);
}

class JSONObject {
    Object get(String key);
    int getIntValue(String key);
    Integer getInteger(String key);
    long getLongValue(String key);
    Long getLong(String key);
    T getObject(String key, Class<T> objectClass);
    
    // 将JSONObject对象转换为Java对象
    T toJavaObject(Class<T> objectClass);
}

class JSONArray {
    Object get(int index);
    int getIntValue(int index);
    Integer getInteger(int index);
    long getLongValue(int index);
    Long getLong(int index);
    T getObject(int index, Class<T> objectClass);
}

class JSONPath {
    // 构造JSONPath
    static JSONPath of(String path);
    // 根据path直接解析输入，会部分解析优化，不会全部解析
    Object extract(JSONReader jsonReader);
    
    // 根据path对对象求值
    Object eval(Object rootObject);
}

class JSONReader {
    // 构造基于String输入的JSONReader
    static JSONReader of(String str);
    
    // 构造基于ut8编码byte数组输入的JSONReader
    static JSONReader of(byte[] utf8Bytes);
    
    // 构造基于char[]输入的JSONReader
    static JSONReader of(char[] chars);
    
    // 构造基于json格式byte数组输入的JSONReader
    static JSONReader ofJSONB(byte[] jsonbBytes)
}
2.3 读取JSON对象
String str = "{\"id\":123}";
JSONObject jsonObject = JSON.parseObject(str);
int id = jsonObject.getIntValue("id");
String str = "[\"id\", 123]";
JSONArray jsonArray = JSON.parseArray(str);
String name = jsonArray.getString(0);
int id = jsonArray.getIntValue(1);
3，将Java Bean对象生成JSON
3.1 Java Bean转JSON字符串
class Product {
 public int id;
 public String name;
}

Product product = new Product();
product.id = 1001;
product.name = "DataWorks";

JSON.toJSONString(product);
// 生成如下的结果
{
 "id" : 1001,
 "name" : "DataWorks"
}

JSON.toJSONString(product, JSONWriter.Feature.BeanToArray);
// 生成如下的结果
[123, "DataWorks"]
3.2 Java Bean转UTF-8的byte[]
Product product = ...;
byte[] utf8JSONBytes = JSON.toJSONBytes(product);
4.3 将JavaBean对象生成JSONB格式的byte[]0. FASTJSON 2.0介绍
FASTJSON v2是FASTJSON项目的重要升级，目标是为下一个十年提供一个高性能的JSON库。通过同一套API，

支持JSON/JSONB两种协议，JSONPath 是一等公民。
支持全量解析和部分解析。
支持Java服务端、客户端Android、大数据场景。
支持Kotlin
支持JSON Schema https://alibaba.github.io/fastjson2/json_schema_cn
支持Android
支持Graal Native-Image
fastjson

相关文档：

JSONB格式文档：
https://alibaba.github.io/fastjson2/jsonb_format_cn
FASTJSON v2性能有了很大提升，具体性能数据看这里：
https://alibaba.github.io/fastjson2/benchmark_cn
1. 使用准备
1.1 添加依赖
在fastjson v2中，groupId和1.x不一样，是com.alibaba.fastjson2：

Maven:

<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.39-SNAPSHOT</version>
</dependency>
Gradle:

dependencies {
    implementation 'com.alibaba.fastjson2:fastjson2:2.0.39-SNAPSHOT'
}
可以在 maven.org 查看最新可用的版本。

1.2 其他模块
Fastjson v1兼容模块
如果原来使用fastjson 1.2.x版本，可以使用兼容包，兼容包不能保证100%兼容，请仔细测试验证，发现问题请及时反馈。

Maven:

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.39-SNAPSHOT</version>
</dependency>
Gradle:

dependencies {
    implementation 'com.alibaba:fastjson:2.0.39-SNAPSHOT'
}
Fastjson Kotlin集成模块
如果项目使用Kotlin，可以使用fastjson-kotlin模块，使用方式上采用kotlin的特性。

Maven:

<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2-kotlin</artifactId>
    <version>2.0.39-SNAPSHOT</version>
</dependency>
Gradle:

dependencies {
    implementation("com.alibaba.fastjson2:fastjson2-kotlin:2.0.39-SNAPSHOT")
}
Fastjson Extension扩展模块
如果项目使用SpringFramework等框架，可以使用fastjson-extension模块，使用方式参考 SpringFramework Support。

Maven:

<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2-extension</artifactId>
    <version>2.0.39-SNAPSHOT</version>
</dependency>
Gradle:

dependencies {
    implementation 'com.alibaba.fastjson2:fastjson2-extension:2.0.39-SNAPSHOT'
}
2 简单使用
在fastjson v2中，package和1.x不一样，是com.alibaba.fastjson2。如果你之前用的是fastjson1，大多数情况直接更包名就即可。

2.1 将JSON解析为JSONObject
Java:

String text = "...";
JSONObject data = JSON.parseObject(text);

byte[] bytes = ...;
JSONObject data = JSON.parseObject(bytes);
Kotlin:

import com.alibaba.fastjson2.*

val text = ... // String
val data = text.parseObject()

val bytes = ... // ByteArray
val data = bytes.parseObject() // JSONObject
2.2 将JSON解析为JSONArray
Java:

String text = "...";
JSONArray data = JSON.parseArray(text);
Kotlin:

import com.alibaba.fastjson2.*

val text = ... // String
val data = text.parseArray() // JSONArray
2.3 将JSON解析为Java对象
Java:

String text = "...";
User data = JSON.parseObject(text, User.class);
Kotlin:

import com.alibaba.fastjson2.*

val text = ... // String
val data = text.to<User>() // User
val data = text.parseObject<User>() // User
2.4 将Java对象序列化为JSON
Java:

Object data = "...";
String text = JSON.toJSONString(data);
byte[] text = JSON.toJSONBytes(data);
Kotlin:

import com.alibaba.fastjson2.*

val data = ... // Any
val text = text.toJSONString() // String
val bytes = text.toJSONByteArray() // ByteArray
2.5 使用JSONObject、JSONArray
2.5.1 获取简单属性
String text = "{\"id\": 2,\"name\": \"fastjson2\"}";
JSONObject obj = JSON.parseObject(text);

int id = obj.getIntValue("id");
String name = obj.getString("name");
String text = "[2, \"fastjson2\"]";
JSONArray array = JSON.parseArray(text);

int id = array.getIntValue(0);
String name = array.getString(1);
2.5.2 读取JavaBean
Java:

JSONArray array = ...
JSONObject obj = ...

User user = array.getObject(0, User.class);
User user = obj.getObject("key", User.class);
Kotlin:

val array = ... // JSONArray
val obj = ... // JSONObject

val user = array.getObject<User>(0)
val user = obj.getObject<User>("key")
2.5.3 转为JavaBean
Java:

JSONArray array = ...
JSONObject obj = ...

User user = obj.toJavaObject(User.class);
List<User> users = array.toJavaList(User.class);
Kotlin:

val array = ... // JSONArray
val obj = ... // JSONObject

val user = obj.toObject<User>() // User
val users = array.toList<User>() // List<User>
2.6 将JavaBean对象序列化为JSON
Java:

class User {
    public int id;
    public String name;
}

User user = new User();
user.id = 2;
user.name = "FastJson2";

String text = JSON.toJSONString(user);
byte[] bytes = JSON.toJSONBytes(user);
Kotlin:

class User(
    var id: Int,
    var name: String
)

val user = User()
user.id = 2
user.name = "FastJson2"

val text = user.toJSONString() // String
val bytes = user.toJSONByteArray() // ByteArray
序列化结果:

{
    "id"   : 2,
    "name" : "FastJson2"
}
3. 进阶使用
3.1 使用JSONB
3.1.1 将JavaBean对象序列化JSONB
User user = ...;
byte[] bytes = JSONB.toBytes(user);
byte[] bytes = JSONB.toBytes(user, JSONWriter.Feature.BeanToArray);
3.1.2 将JSONB数据解析为JavaBean
byte[] bytes = ...
User user = JSONB.parseObject(bytes, User.class);
User user = JSONB.parseObject(bytes, User.class, JSONReader.Feature.SupportBeanArrayMapping);
3.2 使用JSONPath
3.2.1 使用JSONPath读取部分数据
String text = ...;
JSONPath path = JSONPath.of("$.id"); // 缓存起来重复使用能提升性能

JSONReader parser = JSONReader.of(text);
Object result = path.extract(parser);
3.2.2 使用JSONPath读取部分byte[]的数据
byte[] bytes = ...;
JSONPath path = JSONPath.of("$.id"); // 缓存起来重复使用能提升性能

JSONReader parser = JSONReader.of(bytes);
Object result = path.extract(parser);
3.2.3 使用JSONPath读取部分byte[]的数据
byte[] bytes = ...;
JSONPath path = JSONPath.of("$.id"); // 缓存起来重复使用能提升性能

JSONReader parser = JSONReader.ofJSONB(bytes); // 注意这里使用ofJSONB方法
Object result = path.extract(parser);
Product product = ...;
byte[] jsonbBytes = JSONB.toBytes(product);

byte[] jsonbBytes = JSONB.toBytes(product, JSONWriter.Feature.BeanToArray);


